
/* DEFS: readonly CkGroupID _RRMapID;
 */
extern CkGroupID _RRMapID;

/* DEFS: message CkArrayMessage;
 */
#ifndef CK_TEMPLATES_ONLY
void *CMessage_CkArrayMessage::operator new(size_t s){
  return CkArrayMessage::alloc(__idx, s, 0, 0);
}
void *CMessage_CkArrayMessage::operator new(size_t s,const int pb){
  return CkArrayMessage::alloc(__idx, s, 0, pb);
}
void *CMessage_CkArrayMessage::operator new(size_t s, int* sz){
  return CkArrayMessage::alloc(__idx, s, sz, 0);
}
void *CMessage_CkArrayMessage::operator new(size_t s, int* sz,const int pb){
  return CkArrayMessage::alloc(__idx, s, sz, pb);
}
void* CMessage_CkArrayMessage::alloc(int msgnum, size_t sz, int *sizes, int pb) {
  int offsets[1];
  offsets[0] = ALIGN8(sz);
  CkArrayMessage *newmsg = (CkArrayMessage *) CkAllocMsg(msgnum, offsets[0], pb);
  return (void *) newmsg;
}
void* CMessage_CkArrayMessage::pack(CkArrayMessage *msg) {
  return (void *) msg;
}
CkArrayMessage* CMessage_CkArrayMessage::unpack(void* buf) {
  CkArrayMessage *msg = (CkArrayMessage *) buf;
  return msg;
}
int CMessage_CkArrayMessage::__idx=0;
#endif

/* DEFS: message CkArrayElementCreateMsg;
 */
#ifndef CK_TEMPLATES_ONLY
void *CMessage_CkArrayElementCreateMsg::operator new(size_t s){
  return CkArrayElementCreateMsg::alloc(__idx, s, 0, 0);
}
void *CMessage_CkArrayElementCreateMsg::operator new(size_t s,const int pb){
  return CkArrayElementCreateMsg::alloc(__idx, s, 0, pb);
}
void *CMessage_CkArrayElementCreateMsg::operator new(size_t s, int* sz){
  return CkArrayElementCreateMsg::alloc(__idx, s, sz, 0);
}
void *CMessage_CkArrayElementCreateMsg::operator new(size_t s, int* sz,const int pb){
  return CkArrayElementCreateMsg::alloc(__idx, s, sz, pb);
}
void* CMessage_CkArrayElementCreateMsg::alloc(int msgnum, size_t sz, int *sizes, int pb) {
  int offsets[1];
  offsets[0] = ALIGN8(sz);
  CkArrayElementCreateMsg *newmsg = (CkArrayElementCreateMsg *) CkAllocMsg(msgnum, offsets[0], pb);
  return (void *) newmsg;
}
void* CMessage_CkArrayElementCreateMsg::pack(CkArrayElementCreateMsg *msg) {
  return (void *) msg;
}
CkArrayElementCreateMsg* CMessage_CkArrayElementCreateMsg::unpack(void* buf) {
  CkArrayElementCreateMsg *msg = (CkArrayElementCreateMsg *) buf;
  return msg;
}
int CMessage_CkArrayElementCreateMsg::__idx=0;
#endif

/* DEFS: message CkArrayElementMigrateMessage;
 */
#ifndef CK_TEMPLATES_ONLY
void *CMessage_CkArrayElementMigrateMessage::operator new(size_t s){
  return CkArrayElementMigrateMessage::alloc(__idx, s, 0, 0);
}
void *CMessage_CkArrayElementMigrateMessage::operator new(size_t s,const int pb){
  return CkArrayElementMigrateMessage::alloc(__idx, s, 0, pb);
}
void *CMessage_CkArrayElementMigrateMessage::operator new(size_t s, int* sz){
  return CkArrayElementMigrateMessage::alloc(__idx, s, sz, 0);
}
void *CMessage_CkArrayElementMigrateMessage::operator new(size_t s, int* sz,const int pb){
  return CkArrayElementMigrateMessage::alloc(__idx, s, sz, pb);
}
void* CMessage_CkArrayElementMigrateMessage::alloc(int msgnum, size_t sz, int *sizes, int pb) {
  int offsets[1];
  offsets[0] = ALIGN8(sz);
  CkArrayElementMigrateMessage *newmsg = (CkArrayElementMigrateMessage *) CkAllocMsg(msgnum, offsets[0], pb);
  return (void *) newmsg;
}
void* CMessage_CkArrayElementMigrateMessage::pack(CkArrayElementMigrateMessage *msg) {
  return (void *) msg;
}
CkArrayElementMigrateMessage* CMessage_CkArrayElementMigrateMessage::unpack(void* buf) {
  CkArrayElementMigrateMessage *msg = (CkArrayElementMigrateMessage *) buf;
  return msg;
}
int CMessage_CkArrayElementMigrateMessage::__idx=0;
#endif

/* DEFS: message CkArrayCreateMsg;
 */
#ifndef CK_TEMPLATES_ONLY
void *CMessage_CkArrayCreateMsg::operator new(size_t s){
  return CkArrayCreateMsg::alloc(__idx, s, 0, 0);
}
void *CMessage_CkArrayCreateMsg::operator new(size_t s,const int pb){
  return CkArrayCreateMsg::alloc(__idx, s, 0, pb);
}
void *CMessage_CkArrayCreateMsg::operator new(size_t s, int* sz){
  return CkArrayCreateMsg::alloc(__idx, s, sz, 0);
}
void *CMessage_CkArrayCreateMsg::operator new(size_t s, int* sz,const int pb){
  return CkArrayCreateMsg::alloc(__idx, s, sz, pb);
}
void* CMessage_CkArrayCreateMsg::alloc(int msgnum, size_t sz, int *sizes, int pb) {
  int offsets[1];
  offsets[0] = ALIGN8(sz);
  CkArrayCreateMsg *newmsg = (CkArrayCreateMsg *) CkAllocMsg(msgnum, offsets[0], pb);
  return (void *) newmsg;
}
void* CMessage_CkArrayCreateMsg::pack(CkArrayCreateMsg *msg) {
  return (void *) msg;
}
CkArrayCreateMsg* CMessage_CkArrayCreateMsg::unpack(void* buf) {
  CkArrayCreateMsg *msg = (CkArrayCreateMsg *) buf;
  return msg;
}
int CMessage_CkArrayCreateMsg::__idx=0;
#endif

/* DEFS: message CkArrayRemoveMsg;
 */
#ifndef CK_TEMPLATES_ONLY
void *CMessage_CkArrayRemoveMsg::operator new(size_t s){
  return CkArrayRemoveMsg::alloc(__idx, s, 0, 0);
}
void *CMessage_CkArrayRemoveMsg::operator new(size_t s,const int pb){
  return CkArrayRemoveMsg::alloc(__idx, s, 0, pb);
}
void *CMessage_CkArrayRemoveMsg::operator new(size_t s, int* sz){
  return CkArrayRemoveMsg::alloc(__idx, s, sz, 0);
}
void *CMessage_CkArrayRemoveMsg::operator new(size_t s, int* sz,const int pb){
  return CkArrayRemoveMsg::alloc(__idx, s, sz, pb);
}
void* CMessage_CkArrayRemoveMsg::alloc(int msgnum, size_t sz, int *sizes, int pb) {
  int offsets[1];
  offsets[0] = ALIGN8(sz);
  CkArrayRemoveMsg *newmsg = (CkArrayRemoveMsg *) CkAllocMsg(msgnum, offsets[0], pb);
  return (void *) newmsg;
}
void* CMessage_CkArrayRemoveMsg::pack(CkArrayRemoveMsg *msg) {
  return (void *) msg;
}
CkArrayRemoveMsg* CMessage_CkArrayRemoveMsg::unpack(void* buf) {
  CkArrayRemoveMsg *msg = (CkArrayRemoveMsg *) buf;
  return msg;
}
int CMessage_CkArrayRemoveMsg::__idx=0;
#endif

/* DEFS: message CkArrayUpdateMsg;
 */
#ifndef CK_TEMPLATES_ONLY
void *CMessage_CkArrayUpdateMsg::operator new(size_t s){
  return CkArrayUpdateMsg::alloc(__idx, s, 0, 0);
}
void *CMessage_CkArrayUpdateMsg::operator new(size_t s,const int pb){
  return CkArrayUpdateMsg::alloc(__idx, s, 0, pb);
}
void *CMessage_CkArrayUpdateMsg::operator new(size_t s, int* sz){
  return CkArrayUpdateMsg::alloc(__idx, s, sz, 0);
}
void *CMessage_CkArrayUpdateMsg::operator new(size_t s, int* sz,const int pb){
  return CkArrayUpdateMsg::alloc(__idx, s, sz, pb);
}
void* CMessage_CkArrayUpdateMsg::alloc(int msgnum, size_t sz, int *sizes, int pb) {
  int offsets[1];
  offsets[0] = ALIGN8(sz);
  CkArrayUpdateMsg *newmsg = (CkArrayUpdateMsg *) CkAllocMsg(msgnum, offsets[0], pb);
  return (void *) newmsg;
}
void* CMessage_CkArrayUpdateMsg::pack(CkArrayUpdateMsg *msg) {
  return (void *) msg;
}
CkArrayUpdateMsg* CMessage_CkArrayUpdateMsg::unpack(void* buf) {
  CkArrayUpdateMsg *msg = (CkArrayUpdateMsg *) buf;
  return msg;
}
int CMessage_CkArrayUpdateMsg::__idx=0;
#endif

/* DEFS: group CkArray: CkReductionMgr{
CkArray(CkArrayCreateMsg*);
void InsertElement(CkArrayMessage*);
void DoneInserting(void);
void ElementDying(CkArrayRemoveMsg*);
void Send(CkArrayMessage*);
void RecvForElement(CkArrayMessage*);
void RecvMigratedElement(CkArrayElementMigrateMessage*);
void UpdateLocation(CkArrayUpdateMsg*);
void DummyAtSync(void);
void SpringCleaning(void);
void SendBroadcast(CkArrayMessage*);
void RecvBroadcast(CkArrayMessage*);
};
 */
#ifndef CK_TEMPLATES_ONLY
int CProxy_CkArray::__idx=0;
#endif
#ifndef CK_TEMPLATES_ONLY
    void CProxy_CkArray::__register(const char *s, size_t size) {
      __idx = CkRegisterChare(s, size);
  _REGISTER_BASE(__idx, CProxy_CkReductionMgr::__idx);
    /* REG: CkArray(CkArrayCreateMsg*);
*/
      __idx_CkArray_CkArrayCreateMsg = CkRegisterEp("CkArray", (CkCallFnPtr)_call_CkArray_CkArrayCreateMsg, CMessage_CkArrayCreateMsg::__idx, __idx);

    /* REG: void InsertElement(CkArrayMessage*);
*/
      __idx_InsertElement_CkArrayMessage = CkRegisterEp("InsertElement", (CkCallFnPtr)_call_InsertElement_CkArrayMessage, CMessage_CkArrayMessage::__idx, __idx);

    /* REG: void DoneInserting(void);
*/
      __idx_DoneInserting_void = CkRegisterEp("DoneInserting", (CkCallFnPtr)_call_DoneInserting_void, 0, __idx);

    /* REG: void ElementDying(CkArrayRemoveMsg*);
*/
      __idx_ElementDying_CkArrayRemoveMsg = CkRegisterEp("ElementDying", (CkCallFnPtr)_call_ElementDying_CkArrayRemoveMsg, CMessage_CkArrayRemoveMsg::__idx, __idx);

    /* REG: void Send(CkArrayMessage*);
*/
      __idx_Send_CkArrayMessage = CkRegisterEp("Send", (CkCallFnPtr)_call_Send_CkArrayMessage, CMessage_CkArrayMessage::__idx, __idx);

    /* REG: void RecvForElement(CkArrayMessage*);
*/
      __idx_RecvForElement_CkArrayMessage = CkRegisterEp("RecvForElement", (CkCallFnPtr)_call_RecvForElement_CkArrayMessage, CMessage_CkArrayMessage::__idx, __idx);

    /* REG: void RecvMigratedElement(CkArrayElementMigrateMessage*);
*/
      __idx_RecvMigratedElement_CkArrayElementMigrateMessage = CkRegisterEp("RecvMigratedElement", (CkCallFnPtr)_call_RecvMigratedElement_CkArrayElementMigrateMessage, CMessage_CkArrayElementMigrateMessage::__idx, __idx);

    /* REG: void UpdateLocation(CkArrayUpdateMsg*);
*/
      __idx_UpdateLocation_CkArrayUpdateMsg = CkRegisterEp("UpdateLocation", (CkCallFnPtr)_call_UpdateLocation_CkArrayUpdateMsg, CMessage_CkArrayUpdateMsg::__idx, __idx);

    /* REG: void DummyAtSync(void);
*/
      __idx_DummyAtSync_void = CkRegisterEp("DummyAtSync", (CkCallFnPtr)_call_DummyAtSync_void, 0, __idx);

    /* REG: void SpringCleaning(void);
*/
      __idx_SpringCleaning_void = CkRegisterEp("SpringCleaning", (CkCallFnPtr)_call_SpringCleaning_void, 0, __idx);

    /* REG: void SendBroadcast(CkArrayMessage*);
*/
      __idx_SendBroadcast_CkArrayMessage = CkRegisterEp("SendBroadcast", (CkCallFnPtr)_call_SendBroadcast_CkArrayMessage, CMessage_CkArrayMessage::__idx, __idx);

    /* REG: void RecvBroadcast(CkArrayMessage*);
*/
      __idx_RecvBroadcast_CkArrayMessage = CkRegisterEp("RecvBroadcast", (CkCallFnPtr)_call_RecvBroadcast_CkArrayMessage, CMessage_CkArrayMessage::__idx, __idx);
    }
#endif
#ifndef CK_TEMPLATES_ONLY
/* DEFS: CkArray(CkArrayCreateMsg*);
 */
int CProxy_CkArray::__idx_CkArray_CkArrayCreateMsg=0;
CkGroupID CProxy_CkArray::ckNew(CkArrayCreateMsg*msg)
{
  return CkCreateGroup(__idx, __idx_CkArray_CkArrayCreateMsg, msg, 0, 0);
}
CkGroupID CProxy_CkArray::ckNewSync(CkArrayCreateMsg*msg)
{
  return CkCreateGroupSync(__idx, __idx_CkArray_CkArrayCreateMsg, msg);
}
  CProxy_CkArray::CProxy_CkArray(CkArrayCreateMsg*msg, int retEP, CkChareID *cid)
{
  _ck_gid = CkCreateGroup(__idx, __idx_CkArray_CkArrayCreateMsg, msg, retEP, cid);
  _setChare(0);
}
  CProxy_CkArray::CProxy_CkArray(CkArrayCreateMsg*msg)
{
  _ck_gid = CkCreateGroup(__idx, __idx_CkArray_CkArrayCreateMsg, msg, 0, 0);
  _setChare(0);
}
void CProxy_CkArray::_call_CkArray_CkArrayCreateMsg(void* msg, CkArray* obj)
{
  new (obj) CkArray((CkArrayCreateMsg*)msg);
}

/* DEFS: void InsertElement(CkArrayMessage*);
 */
int CProxy_CkArray::__idx_InsertElement_CkArrayMessage=0;
void CProxy_CkArray::_call_InsertElement_CkArrayMessage(void* msg, CkArray* obj)
{
  obj->InsertElement((CkArrayMessage*)msg);
}

/* DEFS: void DoneInserting(void);
 */
int CProxy_CkArray::__idx_DoneInserting_void=0;
void CProxy_CkArray::_call_DoneInserting_void(void* msg, CkArray* obj)
{
  obj->DoneInserting();
  CkFreeSysMsg(msg);
}

/* DEFS: void ElementDying(CkArrayRemoveMsg*);
 */
int CProxy_CkArray::__idx_ElementDying_CkArrayRemoveMsg=0;
void CProxy_CkArray::_call_ElementDying_CkArrayRemoveMsg(void* msg, CkArray* obj)
{
  obj->ElementDying((CkArrayRemoveMsg*)msg);
}

/* DEFS: void Send(CkArrayMessage*);
 */
int CProxy_CkArray::__idx_Send_CkArrayMessage=0;
void CProxy_CkArray::_call_Send_CkArrayMessage(void* msg, CkArray* obj)
{
  obj->Send((CkArrayMessage*)msg);
}

/* DEFS: void RecvForElement(CkArrayMessage*);
 */
int CProxy_CkArray::__idx_RecvForElement_CkArrayMessage=0;
void CProxy_CkArray::_call_RecvForElement_CkArrayMessage(void* msg, CkArray* obj)
{
  obj->RecvForElement((CkArrayMessage*)msg);
}

/* DEFS: void RecvMigratedElement(CkArrayElementMigrateMessage*);
 */
int CProxy_CkArray::__idx_RecvMigratedElement_CkArrayElementMigrateMessage=0;
void CProxy_CkArray::_call_RecvMigratedElement_CkArrayElementMigrateMessage(void* msg, CkArray* obj)
{
  obj->RecvMigratedElement((CkArrayElementMigrateMessage*)msg);
}

/* DEFS: void UpdateLocation(CkArrayUpdateMsg*);
 */
int CProxy_CkArray::__idx_UpdateLocation_CkArrayUpdateMsg=0;
void CProxy_CkArray::_call_UpdateLocation_CkArrayUpdateMsg(void* msg, CkArray* obj)
{
  obj->UpdateLocation((CkArrayUpdateMsg*)msg);
}

/* DEFS: void DummyAtSync(void);
 */
int CProxy_CkArray::__idx_DummyAtSync_void=0;
void CProxy_CkArray::_call_DummyAtSync_void(void* msg, CkArray* obj)
{
  obj->DummyAtSync();
  CkFreeSysMsg(msg);
}

/* DEFS: void SpringCleaning(void);
 */
int CProxy_CkArray::__idx_SpringCleaning_void=0;
void CProxy_CkArray::_call_SpringCleaning_void(void* msg, CkArray* obj)
{
  obj->SpringCleaning();
  CkFreeSysMsg(msg);
}

/* DEFS: void SendBroadcast(CkArrayMessage*);
 */
int CProxy_CkArray::__idx_SendBroadcast_CkArrayMessage=0;
void CProxy_CkArray::_call_SendBroadcast_CkArrayMessage(void* msg, CkArray* obj)
{
  obj->SendBroadcast((CkArrayMessage*)msg);
}

/* DEFS: void RecvBroadcast(CkArrayMessage*);
 */
int CProxy_CkArray::__idx_RecvBroadcast_CkArrayMessage=0;
void CProxy_CkArray::_call_RecvBroadcast_CkArrayMessage(void* msg, CkArray* obj)
{
  obj->RecvBroadcast((CkArrayMessage*)msg);
}
#endif /*CK_TEMPLATES_ONLY*/

/* DEFS: array ArrayElement{
ArrayElement(CkMigrateMessage*);
ArrayElement(void);
void destroy(void);
};
 */
#ifndef CK_TEMPLATES_ONLY
int CProxy_ArrayElement::__idx=0;
#endif
#ifndef CK_TEMPLATES_ONLY
    void CProxy_ArrayElement::__register(const char *s, size_t size) {
      __idx = CkRegisterChare(s, size);
    /* REG: ArrayElement(CkMigrateMessage*);
*/
      __idx_ArrayElement_CkMigrateMessage = CkRegisterEp("ArrayElement", (CkCallFnPtr)_call_ArrayElement_CkMigrateMessage, 0, __idx);

    /* REG: ArrayElement(void);
*/
      __idx_ArrayElement_void = CkRegisterEp("ArrayElement", (CkCallFnPtr)_call_ArrayElement_void, 0, __idx);

    /* REG: void destroy(void);
*/
      __idx_destroy_void = CkRegisterEp("destroy", (CkCallFnPtr)_call_destroy_void, 0, __idx);
      CkRegisterMigCtor(__idx, __idx_ArrayElement_CkMigrateMessage);
    }
#endif
#ifndef CK_TEMPLATES_ONLY
/* DEFS: ArrayElement(CkMigrateMessage*);
 */
int CProxy_ArrayElement::__idx_ArrayElement_CkMigrateMessage=0;
void CProxy_ArrayElement::_call_ArrayElement_CkMigrateMessage(void* msg, ArrayElement* obj)
{
  new (obj) ArrayElement((CkMigrateMessage*)msg);
}

/* DEFS: ArrayElement(void);
 */
int CProxy_ArrayElement::__idx_ArrayElement_void=0;
void CProxy_ArrayElement::insert(int onPE)
{ base_insert(__idx_ArrayElement_void,onPE,NULL);}
void CProxy_ArrayElement::_call_ArrayElement_void(void* msg, ArrayElement* obj)
{
  new (obj) ArrayElement();
  CkFreeMsg(msg);
}

/* DEFS: void destroy(void);
 */
int CProxy_ArrayElement::__idx_destroy_void=0;
void CProxy_ArrayElement::destroy(void) const
{
      CkArrayMessage *msg=(CkArrayMessage*)CkAllocMsg(0, sizeof(CkArrayMessage),0);
      if(_idx.nInts==-1) 
        base_broadcast(msg, __idx_destroy_void);
      else
        base_send(msg, __idx_destroy_void);
}
void CProxy_ArrayElement::_call_destroy_void(void* msg, ArrayElement* obj)
{
  obj->destroy();
  CkFreeMsg(msg);
}
#endif /*CK_TEMPLATES_ONLY*/

/* DEFS: group CkArrayMap: CkGroupInitCallback{
CkArrayMap(void);
};
 */
#ifndef CK_TEMPLATES_ONLY
int CProxy_CkArrayMap::__idx=0;
#endif
#ifndef CK_TEMPLATES_ONLY
    void CProxy_CkArrayMap::__register(const char *s, size_t size) {
      __idx = CkRegisterChare(s, size);
  _REGISTER_BASE(__idx, CProxy_CkGroupInitCallback::__idx);
    /* REG: CkArrayMap(void);
*/
      __idx_CkArrayMap_void = CkRegisterEp("CkArrayMap", (CkCallFnPtr)_call_CkArrayMap_void, 0, __idx);
    }
#endif
#ifndef CK_TEMPLATES_ONLY
/* DEFS: CkArrayMap(void);
 */
int CProxy_CkArrayMap::__idx_CkArrayMap_void=0;
CkGroupID CProxy_CkArrayMap::ckNew(void)
{
      void *msg = CkAllocSysMsg();
  return CkCreateGroup(__idx, __idx_CkArrayMap_void, msg, 0, 0);
}
CkGroupID CProxy_CkArrayMap::ckNewSync(void)
{
      void *msg = CkAllocSysMsg();
  return CkCreateGroupSync(__idx, __idx_CkArrayMap_void, msg);
}
  CProxy_CkArrayMap::CProxy_CkArrayMap(int retEP, CkChareID *cid)
{
      void *msg = CkAllocSysMsg();
  _ck_gid = CkCreateGroup(__idx, __idx_CkArrayMap_void, msg, retEP, cid);
  _setChare(0);
}
  CProxy_CkArrayMap::CProxy_CkArrayMap(void)
{
      void *msg = CkAllocSysMsg();
  _ck_gid = CkCreateGroup(__idx, __idx_CkArrayMap_void, msg, 0, 0);
  _setChare(0);
}
void CProxy_CkArrayMap::_call_CkArrayMap_void(void* msg, CkArrayMap* obj)
{
  new (obj) CkArrayMap();
  CkFreeSysMsg(msg);
}
#endif /*CK_TEMPLATES_ONLY*/

/* DEFS: group RRMap: CkArrayMap{
RRMap(void);
};
 */
#ifndef CK_TEMPLATES_ONLY
int CProxy_RRMap::__idx=0;
#endif
#ifndef CK_TEMPLATES_ONLY
    void CProxy_RRMap::__register(const char *s, size_t size) {
      __idx = CkRegisterChare(s, size);
  _REGISTER_BASE(__idx, CProxy_CkArrayMap::__idx);
    /* REG: RRMap(void);
*/
      __idx_RRMap_void = CkRegisterEp("RRMap", (CkCallFnPtr)_call_RRMap_void, 0, __idx);
    }
#endif
#ifndef CK_TEMPLATES_ONLY
/* DEFS: RRMap(void);
 */
int CProxy_RRMap::__idx_RRMap_void=0;
CkGroupID CProxy_RRMap::ckNew(void)
{
      void *msg = CkAllocSysMsg();
  return CkCreateGroup(__idx, __idx_RRMap_void, msg, 0, 0);
}
CkGroupID CProxy_RRMap::ckNewSync(void)
{
      void *msg = CkAllocSysMsg();
  return CkCreateGroupSync(__idx, __idx_RRMap_void, msg);
}
  CProxy_RRMap::CProxy_RRMap(int retEP, CkChareID *cid)
{
      void *msg = CkAllocSysMsg();
  _ck_gid = CkCreateGroup(__idx, __idx_RRMap_void, msg, retEP, cid);
  _setChare(0);
}
  CProxy_RRMap::CProxy_RRMap(void)
{
      void *msg = CkAllocSysMsg();
  _ck_gid = CkCreateGroup(__idx, __idx_RRMap_void, msg, 0, 0);
  _setChare(0);
}
void CProxy_RRMap::_call_RRMap_void(void* msg, RRMap* obj)
{
  new (obj) RRMap();
  CkFreeSysMsg(msg);
}
#endif /*CK_TEMPLATES_ONLY*/

/* DEFS: mainchare CkArrayInit{
CkArrayInit();
};
 */
#ifndef CK_TEMPLATES_ONLY
int CProxy_CkArrayInit::__idx=0;
#endif
#ifndef CK_TEMPLATES_ONLY
    void CProxy_CkArrayInit::__register(const char *s, size_t size) {
      __idx = CkRegisterChare(s, size);
    /* REG: CkArrayInit();
*/
      __idx_CkArrayInit = CkRegisterEp("CkArrayInit", (CkCallFnPtr)_call_CkArrayInit, 0, __idx);
      CkRegisterMainChare(__idx, __idx_CkArrayInit);
    }
#endif
#ifndef CK_TEMPLATES_ONLY
/* DEFS: CkArrayInit();
 */
int CProxy_CkArrayInit::__idx_CkArrayInit=0;
void CProxy_CkArrayInit::ckNew(int onPE)
{
      void *msg = CkAllocSysMsg();
  CkCreateChare(__idx, __idx_CkArrayInit, msg, 0, onPE);
}
void CProxy_CkArrayInit::ckNew(CkChareID* pcid, int onPE)
{
      void *msg = CkAllocSysMsg();
  CkCreateChare(__idx, __idx_CkArrayInit, msg, pcid, onPE);
}
  CProxy_CkArrayInit::CProxy_CkArrayInit(int onPE)
{
      void *msg = CkAllocSysMsg();
  CkCreateChare(__idx, __idx_CkArrayInit, msg, &_ck_cid, onPE);
}
void CProxy_CkArrayInit::_call_CkArrayInit(CkArgMsg* msg, CkArrayInit* obj)
{
  new (obj) CkArrayInit((CkArgMsg*)msg);
}
#endif /*CK_TEMPLATES_ONLY*/

#ifndef CK_TEMPLATES_ONLY
void _registerCkArray(void)
{
  static int _done = 0; if(_done) return; _done = 1;
      _registerCkReduction();

  CkRegisterReadonly(sizeof(CkGroupID), (void *) &_RRMapID);

/* REG: message CkArrayMessage;
*/
CMessage_CkArrayMessage::__register("CkArrayMessage", sizeof(CkArrayMessage),(CkPackFnPtr) CkArrayMessage::pack,(CkUnpackFnPtr) CkArrayMessage::unpack);

/* REG: message CkArrayElementCreateMsg;
*/
CMessage_CkArrayElementCreateMsg::__register("CkArrayElementCreateMsg", sizeof(CkArrayElementCreateMsg),(CkPackFnPtr) CkArrayElementCreateMsg::pack,(CkUnpackFnPtr) CkArrayElementCreateMsg::unpack);

/* REG: message CkArrayElementMigrateMessage;
*/
CMessage_CkArrayElementMigrateMessage::__register("CkArrayElementMigrateMessage", sizeof(CkArrayElementMigrateMessage),(CkPackFnPtr) CkArrayElementMigrateMessage::pack,(CkUnpackFnPtr) CkArrayElementMigrateMessage::unpack);

/* REG: message CkArrayCreateMsg;
*/
CMessage_CkArrayCreateMsg::__register("CkArrayCreateMsg", sizeof(CkArrayCreateMsg),(CkPackFnPtr) CkArrayCreateMsg::pack,(CkUnpackFnPtr) CkArrayCreateMsg::unpack);

/* REG: message CkArrayRemoveMsg;
*/
CMessage_CkArrayRemoveMsg::__register("CkArrayRemoveMsg", sizeof(CkArrayRemoveMsg),(CkPackFnPtr) CkArrayRemoveMsg::pack,(CkUnpackFnPtr) CkArrayRemoveMsg::unpack);

/* REG: message CkArrayUpdateMsg;
*/
CMessage_CkArrayUpdateMsg::__register("CkArrayUpdateMsg", sizeof(CkArrayUpdateMsg),(CkPackFnPtr) CkArrayUpdateMsg::pack,(CkUnpackFnPtr) CkArrayUpdateMsg::unpack);

/* REG: group CkArray: CkReductionMgr{
CkArray(CkArrayCreateMsg*);
void InsertElement(CkArrayMessage*);
void DoneInserting(void);
void ElementDying(CkArrayRemoveMsg*);
void Send(CkArrayMessage*);
void RecvForElement(CkArrayMessage*);
void RecvMigratedElement(CkArrayElementMigrateMessage*);
void UpdateLocation(CkArrayUpdateMsg*);
void DummyAtSync(void);
void SpringCleaning(void);
void SendBroadcast(CkArrayMessage*);
void RecvBroadcast(CkArrayMessage*);
};
*/
  CProxy_CkArray::__register("CkArray", sizeof(CkArray));

/* REG: array ArrayElement{
ArrayElement(CkMigrateMessage*);
ArrayElement(void);
void destroy(void);
};
*/
  CProxy_ArrayElement::__register("ArrayElement", sizeof(ArrayElement));

/* REG: group CkArrayMap: CkGroupInitCallback{
CkArrayMap(void);
};
*/
  CProxy_CkArrayMap::__register("CkArrayMap", sizeof(CkArrayMap));

/* REG: group RRMap: CkArrayMap{
RRMap(void);
};
*/
  CProxy_RRMap::__register("RRMap", sizeof(RRMap));

/* REG: mainchare CkArrayInit{
CkArrayInit();
};
*/
  CProxy_CkArrayInit::__register("CkArrayInit", sizeof(CkArrayInit));

}
#endif
