#include <stdbool.h>


typedef struct{
int lower,upper,mult,extent;
}Triplet;



typedef struct{
void*addr;
int alloc_size;
int size;
Triplet dim[1];
}Dope1;

typedef struct{
void*addr;
int alloc_size;
int size;
Triplet dim[2];
}Dope2;

typedef struct{
void*addr;
int alloc_size;
int size;
Triplet dim[3];
}Dope3;

typedef struct{
void*addr;
int alloc_size;
int size;
Triplet dim[4];
}Dope4;

typedef struct{
void*addr;
int alloc_size;
int size;
Triplet dim[5];
}Dope5;

typedef struct{
void*addr;
int alloc_size;
int size;
Triplet dim[6];
}Dope6;

typedef struct{
void*addr;
int alloc_size;
int size;
Triplet dim[7];
}Dope7;







void MakeArrayDescriptor_C_long1(Dope1*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_long_long1(Dope1*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
long long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long long int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long long int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_float1(Dope1*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
float*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(float);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (float*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_double1(Dope1*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
double*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(double);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (double*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_bool1(Dope1*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
_Bool*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(_Bool);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (_Bool*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_signed_char1(Dope1*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
signed char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(signed char);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (signed char*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_short1(Dope1*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
short int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(short int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (short int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_char1(Dope1*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(char);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (char*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}




void MakeArrayDescriptor_C_long2(Dope2*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_long_long2(Dope2*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
long long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long long int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long long int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_float2(Dope2*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
float*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(float);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (float*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_double2(Dope2*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
double*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(double);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (double*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_bool2(Dope2*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
_Bool*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(_Bool);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (_Bool*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_signed_char2(Dope2*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
signed char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(signed char);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (signed char*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_short2(Dope2*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
short int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(short int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (short int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_char2(Dope2*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(char);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (char*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}




void MakeArrayDescriptor_C_long3(Dope3*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_long_long3(Dope3*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
long long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long long int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long long int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_float3(Dope3*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
float*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(float);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (float*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_double3(Dope3*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
double*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(double);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (double*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_bool3(Dope3*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
_Bool*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(_Bool);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (_Bool*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_signed_char3(Dope3*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
signed char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(signed char);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (signed char*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_short3(Dope3*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
short int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(short int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (short int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_char3(Dope3*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(char);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (char*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}




void MakeArrayDescriptor_C_long4(Dope4*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_long_long4(Dope4*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
long long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long long int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long long int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_float4(Dope4*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
float*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(float);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (float*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_double4(Dope4*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
double*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(double);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (double*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_bool4(Dope4*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
_Bool*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(_Bool);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (_Bool*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_signed_char4(Dope4*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
signed char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(signed char);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (signed char*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_short4(Dope4*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
short int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(short int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (short int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_char4(Dope4*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(char);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (char*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}




void MakeArrayDescriptor_C_long5(Dope5*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_long_long5(Dope5*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
long long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long long int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long long int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_float5(Dope5*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
float*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(float);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (float*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_double5(Dope5*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
double*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(double);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (double*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_bool5(Dope5*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
_Bool*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(_Bool);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (_Bool*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_signed_char5(Dope5*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
signed char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(signed char);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (signed char*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_short5(Dope5*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
short int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(short int);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (short int*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}


void MakeArrayDescriptor_C_char5(Dope5*array,void**void_address_,int lower_bounds[],int upper_bounds[],int strides[])
{

void*void_address= *void_address_;

int dim,offset,size;
char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(char);
(array->dim[dim].upper)= upper_bounds[dim];
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (char*)void_address;
offset_address= address+offset;
array->addr= void_address;



array->alloc_size= 0;
array->size= size;
}